var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$EventManager = require("EventManager");
var i = cc__importDefault($1$EventManager);
var $1$PlayerDataTemplate = require("PlayerDataTemplate");
var r = cc__importDefault($1$PlayerDataTemplate);
var $1$GameConfig = require("GameConfig");
var a = cc__importDefault($1$GameConfig);
var $GameEventType = require("GameEventType");
var def_PlayerData = function () {
  function _ctor() { }
  _ctor.init = function () {
    // 获取初始数据
    this.Data = r.default.getData();

    // 从本地存储获取玩家数据
    const playerDataKey = `${a.default.gameName}PlayerData`;
    let storedData = cc.sys.localStorage.getItem(playerDataKey);

    if (storedData) {
      // 解析存储的数据
      storedData = JSON.parse(storedData);

      // 复制存储的数据到当前数据
      this.copyObject(this.Data, storedData);

      // 检查玩家皮肤是否已拥有，若未拥有则添加
      const ownedSkins = this.Data.gameData.PlayerSkin.owned;
      if (!ownedSkins.includes(0)) {
        ownedSkins.push(0);
      }
    }

    // 重置尝试皮肤
    this.resetTrySkin();

    // 绑定事件
    this.onEvents();
  };
  _ctor.copyObject = function (t, e) {
    // 遍历对象 e 的每一个属性
    for (const key in e) {
      if (e.hasOwnProperty(key)) {  // 确保是对象自有属性
        switch (typeof e[key]) {
          case "number":
          case "boolean":
          case "string":
            // 直接复制基本类型的值
            t[key] = e[key];
            break;
          case "object":
            if (Array.isArray(e[key])) {
              // 创建数组的浅拷贝
              t[key] = [].concat(e[key]);
            } else {
              // 确保 t[key] 是对象，如果为 null 则初始化为 {}
              if (t[key] === null) {
                t[key] = {};
              }
              // 递归复制对象
              this.copyObject(t[key], e[key]);
            }
            break;
        }
      }
    }
  };
  _ctor.onEvents = function () {
    i.default.on($GameEventType.EventType.PlayerDataEvent.updatePlayerData, this.onUpdatePlayerData, this);
  };
  _ctor.onUpdatePlayerData = function (t) {
    // 检查属性是否包含点
    if (!t.attribute.includes(".")) {
      // 直接更新数据
      this.updateData(this.Data, t.attribute, t.value, t.mode);
    } else {
      // 按点分割属性
      const attributes = t.attribute.split(".");
      let currentData = this.Data;

      // 遍历属性数组，找到最后一个属性的父对象
      for (let i = 0; i < attributes.length - 1; ++i) {
        if (currentData[attributes[i]] == null) {
          cc.log("修改玩家数据失败，玩家数据未定义对应属性：" + attributes[i]);
          cc.log(t);
          return; // 提前返回
        }
        currentData = currentData[attributes[i]]; // 更新当前数据为下一个嵌套对象
      }

      // 更新最后一个属性的数据
      this.updateData(currentData, attributes[attributes.length - 1], t.value, t.mode);
    }

    // 保存数据
    this.saveData();

    // 触发玩家数据变化事件
    i.default.emit($GameEventType.EventType.PlayerDataEvent.playerDataChanged, {
      type: t.type,
      attribute: t.attribute,
      value: this.getData(t.attribute)
    });
  };
  _ctor.updateData = function (t, e, o, n) {
    // 根据操作符 n 更新对象 t[e] 的值
    switch (n) {
      case "+":
        t[e] += parseFloat(o);
        break;
      case "-":
        t[e] -= parseFloat(o);
        break;
      case "*":
        t[e] *= parseFloat(o);
        break;
      case "=":
        t[e] = parseFloat(o);
        break;
      case "push":
        t[e].push(o);
        break;
      default:
        cc.log("数据修改失败，未定义的数据修改方式：" + n);
    }
  };
  _ctor.getData = function (t) {
    // 检查 t 是否存在
    if (!t) {
      return this.Data; // 如果 t 不存在，返回完整数据
    }

    // 如果 t 不包含点，直接返回对应的数据
    if (!t.includes(".")) {
      return this.Data[t];
    }

    // 将 t 按点分割
    const keys = t.split(".");
    let currentData = this.Data;

    // 遍历分割后的键
    for (let i = 0; i < keys.length; ++i) {
      // 如果当前数据中没有对应的属性，返回当前数据
      if (currentData[keys[i]] == null) {
        return currentData;
      }
      // 更新当前数据为下一个嵌套对象
      currentData = currentData[keys[i]];
    }

    return currentData; // 返回最终数据
  };
  _ctor.saveData = function () {
    cc.sys.localStorage.setItem(a.default.gameName + "PlayerData", JSON.stringify(this.Data));
  };
  _ctor.addGold = function (t) {
    // 增加玩家的金币数量
    this.Data.gameData.asset.gold += t;

    // 发送玩家数据变化事件
    i.default.emit($GameEventType.EventType.PlayerDataEvent.playerDataChanged, {
      type: "gameData",
      attribute: "gameData.asset.gold",
      value: this.Data.gameData.asset.gold
    });
  };
  _ctor.subGold = function (t) {
    // 检查是否足够金币以进行扣减
    if (t <= this.Data.gameData.asset.gold) {
      // 扣除指定数量的金币
      this.Data.gameData.asset.gold -= t;
    } else {
      // 如果不足，则将金币数设置为 0
      this.Data.gameData.asset.gold = 0;
    }

    // 发送玩家数据变化事件
    i.default.emit($GameEventType.EventType.PlayerDataEvent.playerDataChanged, {
      type: "gameData",
      attribute: "gameData.asset.gold",
      value: this.Data.gameData.asset.gold
    });
  };
  _ctor.getCurSkinId = function (t) {
    // 获取游戏数据的指定属性
    const gameDataEntry = this.Data.gameData[t];

    // 获取尝试次数，如果没有尝试次数，则使用当前次数
    let tries = gameDataEntry.try;
    if (tries === -1) {
      tries = gameDataEntry.cur;
    }

    return tries; // 返回最终的尝试次数
  };
  _ctor.unlockSkin = function (t, e) {
    // 获取游戏数据的指定属性
    const gameDataEntry = this.Data.gameData[t];

    // 检查给定的元素是否已被拥有
    if (!gameDataEntry.owned.includes(e)) {
      // 如果未拥有，则将其添加到已拥有列表
      gameDataEntry.owned.push(e);

      // 发送玩家数据变化事件
      i.default.emit($GameEventType.EventType.PlayerDataEvent.playerDataChanged, {
        type: "gameData",
        attribute: `gameData.${t}.owned`,
        value: gameDataEntry.owned
      });
    }
  };
  _ctor.setCurSkin = function (t, e) {
    // 获取游戏数据的指定属性
    const gameDataEntry = this.Data.gameData[t];

    // 检查当前值是否与新值不同
    if (gameDataEntry.cur !== e) {
      // 更新当前值
      gameDataEntry.cur = e;

      // 发送玩家数据变化事件
      i.default.emit($GameEventType.EventType.PlayerDataEvent.playerDataChanged, {
        type: "gameData",
        attribute: `gameData.${t}.cur`,
        value: gameDataEntry.cur
      });
    }
  };
  _ctor.onTrySkin = function (t, e) {
    this.Data.gameData[t].try = e;
  };
  _ctor.onTrySkinEnd = function (t) {
    this.Data.gameData[t].try = -1;
  };
  _ctor.resetTrySkin = function () {
    // 获取游戏数据
    const gameData = this.Data.gameData;

    // 遍历游戏数据的每个属性
    for (const key in gameData) {
      // 检查属性是否是对象并且具有 try 属性
      if (typeof gameData[key] === "object" && gameData[key].try) {
        // 将 try 属性设置为 -1
        gameData[key].try = -1;
      }
    }
  };
  _ctor.Data = {};
  return _ctor;
}();
exports.default = def_PlayerData;